package com.dev.utils.app;


import com.dev.DevUtils;
import com.dev.utils.LogUtils;
import ohos.agp.components.Component;
import ohos.agp.components.Text;
import ohos.agp.render.Paint;
import ohos.agp.text.Font;
import ohos.agp.utils.Color;

import java.util.ArrayList;
import java.util.List;

/**
 * detail: Text 工具类
 *
 * @author Ttt
 * <pre>
 *     获取字体信息 Paint.FontMetrics
 *     @see <a href="https://blog.csdn.net/superbigcupid/article/details/47153139"/>
 *     @see <a href="http://www.cnblogs.com/tianzhijiexian/p/4297664.html"/>
 *     <p></p>
 *     Text 设置行间距、行高, 以及字间距
 *     @see <a href="https://blog.csdn.net/shanshan_1117/article/details/79564271"/>
 *     <p></p>
 *     :includeFontPadding
 *     @see <a href="https://blog.csdn.net/bdmh/article/details/78110557"/>
 *     <p></p>
 *     设置文字水平间距: {@link //TextViewUtils#setLetterSpacing(View, float)}
 *     :letterSpacing
 *     设置文字行间距 ( 行高 ): {@link //TextViewUtils#setLineSpacing(View, float)}、{@link// TextViewUtils#setLineSpacingAndMultiplier(View, float, float)}
 *     :lineSpacingExtra
 *     :lineSpacingMultiplier
 *     <p></p>
 *     setPaintFlags:
 *     Paint.ANTI_ALIAS_FLAG 抗锯齿标志
 *     Paint.FILTER_BITMAP_FLAG 使位图过滤的位掩码标志
 *     Paint.DITHER_FLAG 使位图进行有利的抖动的位掩码标志
 *     Paint.UNDERLINE_TEXT_FLAG 下划线
 *     Paint.STRIKE_THRU_TEXT_FLAG 中划线
 *     Paint.FAKE_BOLD_TEXT_FLAG 加粗
 *     Paint.LINEAR_TEXT_FLAG 使文本平滑线性扩展的油漆标志
 *     Paint.SUBPIXEL_TEXT_FLAG 使文本的亚像素定位的绘图标志
 *     Paint.EMBEDDED_BITMAP_TEXT_FLAG 绘制文本时允许使用位图字体的绘图标志
 * </pre>
 */
public final class TextViewUtils {

    private TextViewUtils() {
    }

    // 日志 TAG
    private static final String TAG = TextViewUtils.class.getSimpleName();

    // =================
    // = 获取 Text =
    // =================

    /**
     * 获取 Text
     *
     * @param view {@link Text}
     * @param <T>  泛型
     * @return {@link Text}
     */
    public static <T extends Text> T getTextView(final Component view) {
        if (view != null) {
            try {
                return (T) view;
            } catch (Exception e) {
                LogUtils.error(TAG, e + "getTextView");
            }
        }
        return null;
    }

    // ========
    // = Hint =
    // ========

    /**
     * 获取 Hint 文本
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return {@link Text#getHint()}
     */
    public static <T extends Text> String getHint(final T Text) {
        if (Text != null) {
            if (Text.getHint() != null) {
                return Text.getHint();
            }
        }
        return null;
    }

    /**
     * 获取 Hint 文本
     *
     * @param view {@link Text}
     * @return {@link Text#getHint()}
     */
    public static String getHint(final Component view) {
        return getHint(getTextView(view));
    }

    /**
     * 获取多个 Text Hint 文本
     *
     * @param views View(Text)[]
     * @return {@link List<String>} 多个 Text Hint 文本
     */
    public static List<String> getHints(final Component... views) {
        List<String> lists = new ArrayList<>();
        if (views != null) {
            for (Component view : views) {
                String text = getHint(view);
                if (text != null) {
                    lists.add(text);
                }
            }
        }
        return lists;
    }

    /**
     * 通过需要的宽度, 计算字体大小 ( 最接近该宽度的字体大小 )
     * @param width       需要的宽度
     * @param paint       {@link Paint}
     * @param curTextSize 当前字体大小
     * @param content     待计算内容
     * @return 字体大小
     */
    public static float reckonTextSizeByWidth(
            final int width,
            final Paint paint,
            final float curTextSize,
            final String content
    ) {
        if (paint == null || width <= 0 || curTextSize <= 0 || content == null) return 0f;
        if (StringUtils.isEmpty(content)) return curTextSize;

        // 字体大小
        float textSize = curTextSize;
        // 字体内容宽度
        int calcTextWidth;
        // 特殊处理 ( 防止死循环记录控制 )
        int state = 0; // 1 -=, 2 +=
        // 循环计算
        while (true) {
            // 设置画笔大小
            paint.setTextSize((int) textSize);
            // 获取字体内容宽度
            calcTextWidth = (int) paint.measureText(content);
            // 符合条件则直接返回
            if (calcTextWidth == width) {
                return textSize;
            } else if (calcTextWidth > width) { // 如果计算的字体宽度大于
                textSize -= 0.5f;
                if (state == 2) {
                    if (calcTextWidth < width) {
                        return textSize;
                    }
                }
                state = 1;
            } else {
                textSize += 0.5f;
                if (state == 1) {
                    if (calcTextWidth < width) {
                        return textSize;
                    }
                }
                state = 2;
            }
        }
    }

    /**
     * 获取字体高度
     * @param textView {@link Text}
     * @param <T>      泛型
     * @return 字体高度
     */
    public static <T extends Text> int getTextHeight(final T textView) {
        return textView.getHeight();
    }


    /**
     * 获取字体顶部偏移高度
     * @param textView {@link Text}
     * @param <T>      泛型
     * @return 字体顶部偏移高度
     */
    public static <T extends Text> int getTextTopOffsetHeight(final T textView) {
        return textView.getAroundElementsPadding();
    }

    /**
     * 获取多个 Text Hint 文本
     *
     * @param views Text[]
     * @param <T>   泛型
     * @return {@link List<String>} 多个 Text Hint 文本
     */
    public static <T extends Text> List<String> getHints(final T... views) {
        List<String> lists = new ArrayList<>();
        if (views != null) {
            for (T view : views) {
                String text = getHint(view);
                if (text != null) {
                    lists.add(text);
                }
            }
        }
        return lists;
    }

    /**
     * 设置 Hint 文本
     *
     * @param Text {@link Text}
     * @param text Hint text
     * @param <T>  泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setHint(
            final T Text,
            final CharSequence text
    ) {
        if (Text != null) {
            Text.setHint((String) text);
        }
        return Text;
    }

    /**
     * 设置 Hint 文本
     *
     * @param view {@link Text}
     * @param text Hint text
     * @return {@link Component}
     */
    public static Component setHint(
            final Component view,
            final CharSequence text
    ) {
        setHint(getTextView(view), text);
        return view;
    }

    /**
     * 获取 Hint 字体颜色
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return {@link Color}
     */
    public static <T extends Text> Color getHintTextColors(final T Text) {
        if (Text != null) {
            return Text.getHintColor();
        }
        return null;
    }

    /**
     * 通过需要的高度, 计算字体大小
     * @param height 需要的高度
     * @return 字体大小
     */
    public static float reckonTextSizeByHeight(final int height) {
        Text text = new Text(DevUtils.getContext());
        text.setHeight(height);
        return text.getTextSize();
    }

    /**
     * 计算文本换行行数
     * @param textView {@link Text}
     * @param width    指定的宽度
     * @param <T>      泛型
     * @return 行数
     */
    public static <T extends Text> int calcTextLine(
            final T textView,
            final float width
    ) {
        return (int) (textView.getHeight() / (textView.getTextSize()+(textView.getTextSize() /3*textView.getAdditionalLineSpacing())));
    }


    /**
     * 计算字体宽度
     * @param textView {@link Text}
     * @param <T>      泛型
     * @return 字体宽度
     */
    public static <T extends Text> float getTextWidth(
            final T textView
    ) {
        return textView.getWidth();
    }


    /**
     * 获取 Hint 字体颜色
     *
     * @param view {@link Text}
     * @return {@link Color}
     */
    public static Color getHintTextColors(final Component view) {
        return getHintTextColors(getTextView(view));
    }

    /**
     * 设置 Hint 字体颜色
     *
     * @param Text  {@link Text}
     * @param color R.color.id
     * @param <T>   泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setHintTextColor(
            final T Text,
            final int color
    ) {
        if (Text != null) {
            Text.setHintColor(new Color(color));
        }
        return Text;
    }

    /**
     * 设置 Hint 字体颜色
     *
     * @param view  {@link Text}
     * @param color R.color.id
     * @return {@link Component}
     */
    public static Component setHintTextColor(
            final Component view,
            final int color
    ) {
        setHintTextColor(getTextView(view), color);
        return view;
    }

    /**
     * 设置 Hint 字体颜色
     *
     * @param Text   {@link Text}
     * @param colors {@link Color}
     * @param <T>    泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setHintTextColor(
            final T Text,
            final Color colors
    ) {
        if (Text != null) {
            Text.setHintColor(colors);
        }
        return Text;
    }

    /**
     * 设置 Hint 字体颜色
     *
     * @param view   {@link Text}
     * @param colors {@link Color}
     * @return {@link Component}
     */
    public static Component setHintTextColor(
            final Component view,
            final Color colors
    ) {
        setHintTextColor(getTextView(view), colors);
        return view;
    }

    /**
     * 设置多个 Text Hint 字体颜色
     *
     * @param color R.color.id
     * @param views View(Text)[]
     * @return {@code true} success, {@code false} fail
     */
    public static boolean setHintTextColors(
            final int color,
            final Component... views
    ) {
        if (views != null) {
            for (Component view : views) {
                setHintTextColor(view, color);
            }
            return true;
        }
        return false;
    }

    /**
     * 设置多个 Text Hint 字体颜色
     *
     * @param color R.color.id
     * @param views Text[]
     * @param <T>   泛型
     * @return {@code true} success, {@code false} fail
     */
    public static <T extends Text> boolean setHintTextColors(
            final int color,
            final T... views
    ) {
        if (views != null) {
            for (T view : views) {
                setHintTextColor(view, color);
            }
            return true;
        }
        return false;
    }

    /**
     * 设置多个 Text Hint 字体颜色
     *
     * @param colors {@link Color}
     * @param views  View(Text)[]
     * @return {@code true} success, {@code false} fail
     */
    public static boolean setHintTextColors(
            final Color colors,
            final Component... views
    ) {
        if (views != null) {
            for (Component view : views) {
                setHintTextColor(view, colors);
            }
            return true;
        }
        return false;
    }

    /**
     * 设置多个 Text Hint 字体颜色
     *
     * @param colors {@link Color}
     * @param views  Text[]
     * @param <T>    泛型
     * @return {@code true} success, {@code false} fail
     */
    public static <T extends Text> boolean setHintTextColors(
            final Color colors,
            final T... views
    ) {
        if (views != null) {
            for (T view : views) {
                setHintTextColor(view, colors);
            }
            return true;
        }
        return false;
    }

    // ========
    // = Text =
    // ========

    /**
     * 获取文本
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return {@link Text#getText()} ()}
     */
    public static <T extends Text> String getText(final T Text) {
        if (Text != null) {
            return Text.getText().toString();
        }
        return null;
    }

    /**
     * 获取文本
     *
     * @param view {@link Text}
     * @return {@link Text#getText()}
     */
    public static String getText(final Component view) {
        return getText(getTextView(view));
    }

    /**
     * 获取多个 Text 文本
     *
     * @param views View(Text)[]
     * @return {@link List<String>} 多个 Text 文本
     */
    public static List<String> getTexts(final Component... views) {
        List<String> lists = new ArrayList<>();
        if (views != null) {
            for (Component view : views) {
                String text = getText(view);
                if (text != null) {
                    lists.add(text);
                }
            }
        }
        return lists;
    }

    /**
     * 获取多个 Text 文本
     *
     * @param views Text[]
     * @param <T>   泛型
     * @return {@link List<String>} 多个 Text 文本
     */
    public static <T extends Text> List<String> getTexts(final T... views) {
        List<String> lists = new ArrayList<>();
        if (views != null) {
            for (T view : views) {
                String text = getText(view);
                if (text != null) {
                    lists.add(text);
                }
            }
        }
        return lists;
    }

    /**
     * 设置文本
     *
     * @param Text {@link Text}
     * @param text Text text
     * @param <T>  泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setText(
            final T Text,
            final CharSequence text
    ) {
        if (Text != null) {
            Text.setText((String) text);
        }
        return Text;
    }

    /**
     * 设置文本
     *
     * @param view {@link Text}
     * @param text Text text
     * @return {@link Component}
     */
    public static Component setText(
            final Component view,
            final CharSequence text
    ) {
        setText(getTextView(view), text);
        return view;
    }

    /**
     * 设置多个 Text 文本
     *
     * @param text  Text text
     * @param views View(Text)[]
     * @return {@code true} success, {@code false} fail
     */
    public static boolean setTexts(
            final CharSequence text,
            final Component... views
    ) {
        if (views != null) {
            for (Component view : views) {
                setText(view, text);
            }
            return true;
        }
        return false;
    }

    /**
     * 设置多个 Text 文本
     *
     * @param text  Text text
     * @param views Text[]
     * @param <T>   泛型
     * @return {@code true} success, {@code false} fail
     */
    public static <T extends Text> boolean setTexts(
            final CharSequence text,
            final T... views
    ) {
        if (views != null) {
            for (T view : views) {
                setText(view, text);
            }
            return true;
        }
        return false;
    }

    /**
     * 获取字体颜色
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return {@link Color}
     */
    public static <T extends Text> Color getTextColors(final T Text) {
        if (Text != null) {
            return Text.getTextColor();
        }
        return null;
    }

    /**
     * 获取字体颜色
     *
     * @param view {@link Text}
     * @return {@link Color}
     */
    public static Color getTextColors(final Component view) {
        return getTextColors(getTextView(view));
    }

    /**
     * 设置字体颜色
     *
     * @param Text  {@link Text}
     * @param color R.color.id
     * @param <T>   泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setTextColor(
            final T Text,
            final int color
    ) {
        if (Text != null) {
            Text.setTextColor(new Color(color));
        }
        return Text;
    }

    /**
     * 设置字体颜色
     *
     * @param view  {@link Text}
     * @param color R.color.id
     * @return {@link Component}
     */
    public static Component setTextColor(
            final Component view,
            final int color
    ) {
        setTextColor(getTextView(view), color);
        return view;
    }

    /**
     * 设置字体颜色
     *
     * @param Text   {@link Text}
     * @param colors {@link Color}
     * @param <T>    泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setTextColor(
            final T Text,
            final Color colors
    ) {
        if (Text != null) {
            Text.setTextColor(colors);
        }
        return Text;
    }

    /**
     * 设置字体颜色
     *
     * @param view   {@link Text}
     * @param colors {@link Color}
     * @return {@link Component}
     */
    public static Component setTextColor(
            final Component view,
            final Color colors
    ) {
        setTextColor(getTextView(view), colors);
        return view;
    }

    /**
     * 设置多个 Text 字体颜色
     *
     * @param color R.color.id
     * @param views View(Text)[]
     * @return {@code true} success, {@code false} fail
     */
    public static boolean setTextColors(
            final int color,
            final Component... views
    ) {
        if (views != null) {
            for (Component view : views) {
                setTextColor(view, color);
            }
            return true;
        }
        return false;
    }

    /**
     * 设置多个 Text 字体颜色
     *
     * @param color R.color.id
     * @param views Text[]
     * @param <T>   泛型
     * @return {@code true} success, {@code false} fail
     */
    public static <T extends Text> boolean setTextColors(
            final int color,
            final T... views
    ) {
        if (views != null) {
            for (T view : views) {
                setTextColor(view, color);
            }
            return true;
        }
        return false;
    }

    /**
     * 设置多个 Text 字体颜色
     *
     * @param colors {@link Color}
     * @param views  View(Text)[]
     * @return {@code true} success, {@code false} fail
     */
    public static boolean setTextColors(
            final Color colors,
            final Component... views
    ) {
        if (views != null) {
            for (Component view : views) {
                setTextColor(view, colors);
            }
            return true;
        }
        return false;
    }

    /**
     * 设置多个 Text 字体颜色
     *
     * @param colors {@link Color}
     * @param views  Text[]
     * @param <T>    泛型
     * @return {@code true} success, {@code false} fail
     */
    public static <T extends Text> boolean setTextColors(
            final Color colors,
            final T... views
    ) {
        if (views != null) {
            for (T view : views) {
                setTextColor(view, colors);
            }
            return true;
        }
        return false;
    }

    // ========
    // = Html =
    // ========

    /**
     * 设置 Html 内容
     *
     * @param Text    {@link Text}
     * @param content Html content
     * @param <T>     泛型
     * @return {@link Text}
     */
   /* public static <T extends Text> T setHtmlText(
            final T Text,
            final String content
    ) {
        if (Text != null && content != null) {
            if (Buil.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                Text.setText(Html.fromHtml(content, Html.FROM_HTML_MODE_LEGACY));
            } else {
                Text.setText(Html.fromHtml(content));
            }
        }
        return Text;
    }*/

    /**
     * 设置 Html 内容
     *
     * @param view    {@link Text}
     * @param content Html content
     * @return {@link Component}
     */
    public static Component setHtmlText(
            final Component view,
            final String content
    ) {
        setHtmlText(getTextView(view), content);
        return view;
    }

    /**
     * 设置多个 Text Html 内容
     *
     * @param content Html content
     * @param views   View(Text)[]
     * @return {@code true} success, {@code false} fail
     */
    public static boolean setHtmlTexts(
            final String content,
            final Component... views
    ) {
        if (content != null && views != null) {
            for (Component view : views) {
                setHtmlText(view, content);
            }
            return true;
        }
        return false;
    }

    /**
     * 设置多个 Text Html 内容
     *
     * @param content Html content
     * @param views   Text[]
     * @param <T>     泛型
     * @return {@code true} success, {@code false} fail
     */
    public static <T extends Text> boolean setHtmlTexts(
            final String content,
            final T... views
    ) {
        if (content != null && views != null) {
            for (T view : views) {
                setHtmlText(view, content);
            }
            return true;
        }
        return false;
    }

    // ===========
    // = 字体相关 =
    // ===========

    /**
     * 获取字体
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return {@link Font}
     */
    public static <T extends Text> Font getTypeface(final T Text) {
        if (Text != null) {
            return Text.getFont();
        }
        return null;
    }

    /**
     * 设置字体
     *
     * @param Text     {@link Text}
     * @param typeface {@link Font} 字体样式
     * @param <T>      泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setTypeface(
            final T Text,
            final Font typeface
    ) {
        if (Text != null && typeface != null) {
            Text.setFont(typeface);
        }
        return Text;
    }

    /**
     * 设置字体
     *
     * @param Text     {@link Text}
     * @param typeface {@link Font} 字体样式
     * @param style    样式
     * @param <T>      泛型
     * @return {@link Text}
     */
  /*  public static <T extends Text> T setTypeface(
            final T Text,
            final Font typeface,
            final int style
    ) {
        if (Text != null && typeface != null) {
            Text.setFont(typeface, style);
        }
        return Text;
    }*/

    /**
     * 设置字体
     *
     * @param view     {@link Text}
     * @param typeface {@link Font} 字体样式
     * @return {@link Component}
     */
    public static Component setTypeface(
            final Component view,
            final Font typeface
    ) {
        setTypeface(getTextView(view), typeface);
        return view;
    }

    /**
     * 设置字体
     *
     * @param view     {@link Text}
     * @param typeface {@link Font} 字体样式
     * @param style    样式
     * @return {@link Component}
     */
    public static Component setTypeface(
            final Component view,
            final Font typeface,
            final int style
    ) {
        setTypeface(getTextView(view), typeface, style);
        return view;
    }

    // =

    /**
     * 设置字体大小 ( px 像素 )
     *
     * @param Text {@link Text}
     * @param size 字体大小
     * @param <T>  泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setTextSizeByPx(
            final T Text,
            final int size
    ) {
        return setTextSize(Text, ohos.agp.components.Text.TextSizeType.PX, size);
    }

    /**
     * 设置字体大小(vp)
     *
     * @param Text {@link Text}
     * @param size 字体大小
     * @param <T>  泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setTextSizeByVp(final T Text, final int size) {
        return setTextSize(Text, ohos.agp.components.Text.TextSizeType.VP, size);
    }

    /**
     * 设置字体大小(fp)
     *
     * @param Text {@link Text}
     * @param size 字体大小
     * @param <T>  泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setTextSizeByFp(final T Text, final int size) {
        return setTextSize(Text, ohos.agp.components.Text.TextSizeType.FP, size);
    }

    /**
     * 设置字体大小 ( sp 缩放像素 )
     *
     * @param Text {@link Text}
     * @param size 字体大小
     * @param <T>  泛型
     * @return {@link Text}
     */
   /* public static <T extends Text> T setTextSizeBySp(
            final T Text,
            final float size
    ) {
        return setTextSize(Text, TypedValue.COMPLEX_UNIT_SP, size);
    }
*/
    /**
     * 设置字体大小 ( dp 与设备无关的像素 )
     *
     * @param Text {@link Text}
     * @param size 字体大小
     * @param <T>  泛型
     * @return {@link Text}
     */
    /*public static <T extends Text> T setTextSizeByDp(
            final T Text,
            final float size
    ) {
        return setTextSize(Text, TypedValue.COMPLEX_UNIT_DIP, size);
    }*/

    /**
     * 设置字体大小 ( inches 英寸 )
     *
     * @param Text {@link Text}
     * @param size 字体大小
     * @param <T>  泛型
     * @return {@link Text}
     */
    /*public static <T extends Text> T setTextSizeByIn(
            final T Text,
            final float size
    ) {
        return setTextSize(Text, TypedValue.COMPLEX_UNIT_IN, size);
    }*/

    // =

    /**
     * 设置字体大小 ( px 像素 )
     *
     * @param view {@link Text}
     * @param size 字体大小
     * @return {@link Component}
     */
  /*  public static View setTextSizeByPx(
            final View view,
            final float size
    ) {
        setTextSize(getTextView(view), TypedValue.COMPLEX_UNIT_PX, size);
        return view;
    }*/

    /**
     * 设置字体大小 ( sp 缩放像素 )
     *
     * @param view {@link Text}
     * @param size 字体大小
     * @return {@link Component}
     */
   /* public static View setTextSizeBySp(
            final View view,
            final float size
    ) {
        setTextSize(getTextView(view), TypedValue.COMPLEX_UNIT_SP, size);
        return view;
    }*/

    /**
     * 设置字体大小 ( dp 与设备无关的像素 )
     *
     * @param view {@link Text}
     * @param size 字体大小
     * @return {@link Component}
     */
   /* public static View setTextSizeByDp(
            final View view,
            final float size
    ) {
        setTextSize(getTextView(view), TypedValue.COMPLEX_UNIT_DIP, size);
        return view;
    }*/

    /**
     * 设置字体大小 ( inches 英寸 )
     *
     * @param view {@link Text}
     * @param size 字体大小
     * @return {@link Component}
     */
   /* public static View setTextSizeByIn(
            final View view,
            final float size
    ) {
        setTextSize(getTextView(view), TypedValue.COMPLEX_UNIT_IN, size);
        return view;
    }*/

    // =

    /**
     * 设置字体大小
     *
     * @param Text {@link Text}
     * @param unit 字体参数类型
     * @param size 字体大小
     * @param <T>  泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setTextSize(
            final T Text,
            final Text.TextSizeType unit,
            final int size
    ) {
        if (Text != null) {
            Text.setTextSize(size, unit);
        }
        return Text;
    }

    /**
     * 设置字体大小
     *
     * @param view {@link Text}
     * @param unit 字体参数类型
     * @param size 字体大小
     * @return {@link Component}
     */
    public static Component setTextSize(
            final Component view,
            final Text.TextSizeType unit,
            final int size
    ) {
        setTextSize(getTextView(view), unit, size);
        return view;
    }

    // =

    /**
     * 设置多个 Text 字体大小
     *
     * @param views View(Text)[]
     * @param unit  参数类型
     * @param size  字体大小
     * @return {@code true} success, {@code false} fail
     */
    public static boolean setTextSizes(
            final Component[] views,
            final Text.TextSizeType unit,
            final int size
    ) {
        if (views != null) {
            for (Component view : views) {
                setTextSize(view, unit, size);
            }
            return true;
        }
        return false;
    }

    /**
     * 设置多个 Text 字体大小
     *
     * @param views Text[]
     * @param unit  参数类型
     * @param size  字体大小
     * @param <T>   泛型
     * @return {@code true} success, {@code false} fail
     */
    public static <T extends Text> boolean setTextSizes(
            final T[] views,
            final Text.TextSizeType unit,
            final int size
    ) {
        if (views != null) {
            for (T view : views) {
                setTextSize(view, unit, size);
            }
            return true;
        }
        return false;
    }

    // =

    /**
     * 获取 Text 字体大小 ( px )
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return 字体大小 (px)
     */
    public static <T extends Text> float getTextSize(final T Text) {
        if (Text != null) {
            return Text.getTextSize();
        }
        return -1f;
    }

    /**
     * 获取 Text 字体大小 ( px )
     *
     * @param view {@link Text}
     * @return 字体大小 (px)
     */
    public static float getTextSize(final Component view) {
        return getTextSize(getTextView(view));
    }

    // =

    /**
     * 清空 flags
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return {@link Text}
     */
  /*  public static <T extends Text> T clearFlags(final T Text) {
        if (Text != null) {
            Text.setPaintFlags(0);
        }
        return Text;
    }*/

    /**
     * 清空 flags
     *
     * @param view {@link Text}
     * @return {@link Component}
     */
   /* public static View clearFlags(final View view) {
        clearFlags(getTextView(view));
        return view;
    }*/

    // =

    /**
     * 设置 Text flags
     *
     * @param Text  {@link Text}
     * @param flags flags
     * @param <T>   泛型
     * @return {@link Text}
     */
   /* public static <T extends Text> T setPaintFlags(
            final T Text,
            final int flags
    ) {
        if (Text != null) {
            Text.setPaintFlags(flags);
        }
        return Text;
    }*/

    /**
     * 设置 Text flags
     *
     * @param view  {@link Text}
     * @param flags flags
     * @return {@link Component}
     */
   /* public static View setPaintFlags(
            final View view,
            final int flags
    ) {
        setPaintFlags(getTextView(view), flags);
        return view;
    }*/

    /**
     * 设置 Text 抗锯齿 flags
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return {@link Text}
     */
/*    public static <T extends Text> T setAntiAliasFlag(final T Text) {
        if (Text != null) {
            Text.setPaintFlags(Paint.ANTI_ALIAS_FLAG);
        }
        return Text;
    }*/

    /**
     * 设置 Text 抗锯齿 flags
     *
     * @param view {@link Text}
     * @return {@link Component}
     */
   /* public static View setAntiAliasFlag(final View view) {
        setAntiAliasFlag(getTextView(view));
        return view;
    }
*/

    /**
     * 设置 Text 是否加粗
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setBold(final T Text) {
        return setBold(Text, true);
    }

    /**
     * 设置 Text 是否加粗
     *
     * @param Text   {@link Text}
     * @param isBold {@code true} yes, {@code false} no
     * @param <T>    泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setBold(
            final T Text,
            final boolean isBold
    ) {
        if (Text != null) {
            if (isBold) {
                Text.setFont(Font.DEFAULT_BOLD);
            } else {
                Text.setFont(Font.DEFAULT);
            }
        }
        return Text;
    }

    /**
     * 设置 Text 是否加粗
     *
     * @param Text     {@link Text}
     * @param typeface {@link Font} 字体样式
     * @param isBold   {@code true} yes, {@code false} no
     * @param <T>      泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setBold(
            final T Text,
            final Font typeface,
            final boolean isBold
    ) {
        if (Text != null && typeface != null) {
            if (isBold) {
                Text.setFont(Font.DEFAULT_BOLD);
            } else {
                Text.setFont(Font.DEFAULT);
            }
            // Text.setFont(typeface, isBold ? Typeface.BOLD : Typeface.NORMAL);
        }
        return Text;
    }

    /**
     * 设置 Text 是否加粗
     *
     * @param view {@link Text}
     * @return {@link Component}
     */
    public static Component setBold(final Component view) {
        setBold(getTextView(view), true);
        return view;
    }

    /**
     * 设置 Text 是否加粗
     *
     * @param view   {@link Text}
     * @param isBold {@code true} yes, {@code false} no
     * @return {@link Component}
     */
    public static Component setBold(
            final Component view,
            final boolean isBold
    ) {
        setBold(getTextView(view), isBold);
        return view;
    }

    /**
     * 设置 Text 是否加粗
     *
     * @param view     {@link Text}
     * @param typeface {@link Font} 字体样式
     * @param isBold   {@code true} yes, {@code false} no
     * @return {@link Component}
     */
    public static Component setBold(
            final Component view,
            final Font typeface,
            final boolean isBold
    ) {
        setBold(getTextView(view), typeface, isBold);
        return view;
    }

    // =

    /**
     * 设置下划线
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return {@link Text}
     */
    /*public static <T extends Text> T setUnderlineText(final T Text) {
        return setUnderlineText(Text, true);
    }*/

    /**
     * 设置下划线并加清晰
     *
     * @param Text        {@link Text}
     * @param isAntiAlias 是否消除锯齿
     * @param <T>         泛型
     * @return {@link Text}
     */
   /* public static <T extends Text> T setUnderlineText(
            final T Text,
            final boolean isAntiAlias
    ) {
        if (Text != null) {
            Text.setPaintFlags(Text.getPaintFlags() | Paint.UNDERLINE_TEXT_FLAG);
            if (isAntiAlias) {
                Text.setPaintFlags(Text.getPaintFlags() | Paint.ANTI_ALIAS_FLAG);
            }
        }
        return Text;
    }*/

    // =

    /**
     * 设置下划线
     *
     * @param view {@link Text}
     * @return {@link Component}
     */
    public static Component setUnderlineText(final Component view) {
        setUnderlineText(getTextView(view), true);
        return view;
    }

    /**
     * 设置下划线并加清晰
     *
     * @param view        {@link Text}
     * @param isAntiAlias 是否消除锯齿
     * @return {@link Component}
     */
    public static Component setUnderlineText(
            final Component view,
            final boolean isAntiAlias
    ) {
        setUnderlineText(getTextView(view), isAntiAlias);
        return view;
    }

    // =

    /**
     * 设置中划线
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return {@link Text}
     */
  /*  public static <T extends Text> T setStrikeThruText(final T Text) {
        return setStrikeThruText(Text, true);
    }
*/
    /**
     * 设置中划线并加清晰
     *
     * @param Text        {@link Text}
     * @param isAntiAlias 是否消除锯齿
     * @param <T>         泛型
     * @return {@link Text}
     */
    /*public static <T extends Text> T setStrikeThruText(
            final T Text,
            final boolean isAntiAlias
    ) {
        if (Text != null) {
            Text.set(Text.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
            if (isAntiAlias) {
                Text.setPaintFlags(Text.getPaintFlags() | Paint.ANTI_ALIAS_FLAG);
            }
        }
        return Text;
    }
*/
    // =

    /**
     * 设置中划线
     *
     * @param view {@link Text}
     * @return {@link Component}
     */
  /*  public static View setStrikeThruText(final View view) {
        setStrikeThruText(getTextView(view), true);
        return view;
    }*/

    /**
     * 设置中划线并加清晰
     *
     * @param view        {@link Text}
     * @param isAntiAlias 是否消除锯齿
     * @return {@link Component}
     */
    /*public static View setStrikeThruText(
            final View view,
            final boolean isAntiAlias
    ) {
        setStrikeThruText(getTextView(view), isAntiAlias);
        return view;
    }*/

    // =

    /**
     * 获取文字水平间距
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return 文字水平间距
     */
    /*@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public static <T extends Text> float getLetterSpacing(final T Text) {
        if (Text != null) {
            return Text.getLetterSpacing();
        }
        return 0f;
    }*/

    /**
     * 设置文字水平间距
     * <pre>
     *     :letterSpacing
     * </pre>
     *
     * @param Text          {@link Text}
     * @param letterSpacing 文字水平间距
     * @param <T>           泛型
     * @return {@link Text}
     */
   /* @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public static <T extends Text> T setLetterSpacing(
            final T Text,
            final float letterSpacing
    ) {
        if (Text != null) {
            Text.setLetterSpacing(letterSpacing);
        }
        return Text;
    }*/

    /**
     * 设置文字水平间距
     *
     * @param view          {@link Text}
     * @param letterSpacing 文字水平间距
     * @return {@link Component}
     */
    // @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public static Component setLetterSpacing(
            final Component view,
            final float letterSpacing
    ) {
        setLetterSpacing(getTextView(view), letterSpacing);
        return view;
    }

    // =

    /**
     * 获取文字行间距 ( 行高 )
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return 文字行间距 ( 行高 )
     */
    //@RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
    public static <T extends Text> float getLineSpacingExtra(final T Text) {
        if (Text != null) {
            return Text.getAdditionalLineSpacing();
        }
        return 0f;
    }

    /**
     * 获取文字行间距倍数
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return 文字行间距倍数
     */
    /*@RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
    public static <T extends Text> float getLineSpacingMultiplier(final T Text) {
        if (Text != null) {
            return Text.getLineSpacingMultiplier();
        }
        return 0f;
    }*/

    /**
     * 设置文字行间距 ( 行高 )
     *
     * @param Text        {@link Text}
     * @param lineSpacing 文字行间距 ( 行高 ), :lineSpacingExtra
     * @param <T>         泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setLineSpacing(
            final T Text,
            final float lineSpacing
    ) {
        return setLineSpacingAndMultiplier(Text, lineSpacing, 1.0f);
    }

    /**
     * 设置文字行间距 ( 行高 )、行间距倍数
     *
     * @param Text        {@link Text}
     * @param lineSpacing 文字行间距 ( 行高 ), lineSpacingExtra
     * @param multiplier  行间距倍数, lineSpacingMultiplier
     * @param <T>         泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setLineSpacingAndMultiplier(
            final T Text,
            final float lineSpacing,
            final float multiplier
    ) {
        if (Text != null) {
            Text.setLineSpacing(lineSpacing, multiplier);
        }
        return Text;
    }

    // =

    /**
     * 设置文字行间距 ( 行高 )
     *
     * @param view        {@link Text}

     * @return {@link Component}
     */
    public static Component setLineSpacing(
            final Component view,
            final float lineSpacing
    ) {
        setLineSpacingAndMultiplier(getTextView(view), lineSpacing, 1.0f);
        return view;
    }

    /**
     * 设置文字行间距 ( 行高 )、行间距倍数
     *
     * @param view        {@link Text}


     * @return {@link Component}
     */
    public static Component setLineSpacingAndMultiplier(
            final Component view,
            final float lineSpacing,
            final float multiplier
    ) {
        setLineSpacingAndMultiplier(getTextView(view), lineSpacing, multiplier);
        return view;
    }

    // =

    /**
     * 获取字体水平方向的缩放
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return 字体水平方向的缩放
     */
    public static <T extends Text> float getTextScaleX(final T Text) {
        if (Text != null) {
            return Text.getScaleX();
        }
        return 0f;
    }

    /**
     * 设置字体水平方向的缩放
     * <pre>
     *
     * </pre>
     *
     * @param Text {@link Text}
     * @param size 缩放比例
     * @param <T>  泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setTextScaleX(
            final T Text,
            final float size
    ) {
        if (Text != null) {
            Text.setScaleX(size);
        }
        return Text;
    }

    /**
     * 设置字体水平方向的缩放
     *
     * @param view {@link Text}
     * @param size 缩放比例
     * @return {@link Component}
     */
    public static Component setTextScaleX(
            final Component view,
            final float size
    ) {
        setTextScaleX(getTextView(view), size);
        return view;
    }

    // =

    /**
     * 是否保留字体留白间隙区域
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return {@code true} yes, {@code false} no
     */
    // @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
    public static <T extends Text> boolean getIncludeFontPadding(final T Text) {
        if (Text != null) {
            return Text.getPaddingForText();
        }
        return false;
    }

    /**
     * 设置是否保留字体留白间隙区域


     *
     * @param Text           {@link Text}
     * @param includePadding 是否保留字体留白间隙区域
     * @param <T>            泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setIncludeFontPadding(
            final T Text,
            final boolean includePadding
    ) {
        if (Text != null) {
            Text.setPaddingForText(includePadding);
        }
        return Text;
    }

    /**
     * 设置是否保留字体留白间隙区域
     *
     * @param view           {@link Text}
     * @param includePadding 是否保留字体留白间隙区域
     * @return {@link Component}
     */
    public static Component setIncludeFontPadding(
            final Component view,
            final boolean includePadding
    ) {
        setIncludeFontPadding(getTextView(view), includePadding);
        return view;
    }

    // =

    /**
     * 获取输入类型
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return 输入类型
     */
    public static <T extends Text> int getInputType(final T Text) {
        if (Text != null) {
            return Text.getInputMethodOption();
        }
        return 0;
    }

    /**
     * 设置输入类型
     *
     * @param Text {@link Text}
     * @param type 类型
     * @param <T>  泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setInputType(
            final T Text,
            final int type
    ) {
        if (Text != null) {
            Text.setInputMethodOption(type);
        }
        return Text;
    }

    /**
     * 设置输入类型
     *
     * @param view {@link Text}
     * @param type 类型
     * @return {@link Component}
     */
    public static Component setInputType(
            final Component view,
            final int type
    ) {
        setInputType(getTextView(view), type);
        return view;
    }

    // =

    /**
     * 获取软键盘右下角按钮类型
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return 软键盘右下角按钮类型
     */
  /*  public static <T extends Text> int getImeOptions(final T Text) {
        if (Text != null) {
            return Text.getImeOptions();
        }
        return 0;
    }*/

    /**
     * 设置软键盘右下角按钮类型
     *
     * @param Text       {@link Text}
     * @param imeOptions 软键盘按钮类型
     * @param <T>        泛型
     * @return {@link Text}
     */
/*    public static <T extends Text> T setImeOptions(
            final T Text,
            final int imeOptions
    ) {
        if (Text != null) {
            Text.setImeOptions(imeOptions);
        }
        return Text;
    }*/

    /**
     * 设置软键盘右下角按钮类型
     *
     * @param view       {@link Text}
     * @param imeOptions 软键盘按钮类型
     * @return {@link Component}
     */
    public static Component setImeOptions(
            final Component view,
            final int imeOptions
    ) {
        setImeOptions(getTextView(view), imeOptions);
        return view;
    }

    // =

    /**
     * 设置行数
     *
     * @param Text  {@link Text}
     * @param lines 行数
     * @param <T>   泛型
     * @return {@link Text}
     */
  /*  public static <T extends Text> T setLines(
            final T Text,
            final int lines
    ) {
        if (Text != null) {
            Text.setLines(lines);
        }
        return Text;
    }*/

    /**
     * 设置行数
     *
     * @param view  {@link Text}
     * @param lines 行数
     * @return {@link Component}
     */
   /* public static View setLines(
            final View view,
            final int lines
    ) {
        setLines(getTextView(view), lines);
        return view;
    }
*/
    // =

    /**
     * 获取最大行数
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return 最大行数
     */
    //@RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
    public static <T extends Text> int getMaxLines(final T Text) {
        if (Text != null) {
            return Text.getMaxTextLines();
        }
        return 0;
    }

    /**
     * 设置最大行数
     *
     * @param Text     {@link Text}
     * @param maxLines 最大行数
     * @param <T>      泛型
     * @return {@link Text}
     */
    public static <T extends Text> T setMaxLines(
            final T Text,
            final int maxLines
    ) {
        if (Text != null) {
            Text.setMaxTextLines(maxLines);
        }
        return Text;
    }

    /**
     * 设置最大行数
     *
     * @param view     {@link Text}
     * @param maxLines 最大行数
     * @return {@link Component}
     */
    public static Component setMaxLines(
            final Component view,
            final int maxLines
    ) {
        setMaxLines(getTextView(view), maxLines);
        return view;
    }

    // =

    /**
     * 获取最小行数
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return 最小行数
     */
    // @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
  /*  public static <T extends Text> int getMinLines(final T Text) {
        if (Text != null) {
            return Text.getMinLines();
        }
        return 0;
    }*/

    /**
     * 设置最小行数
     *
     * @param Text     {@link Text}
     * @param minLines 最小行数
     * @param <T>      泛型
     * @return {@link Text}
     */
/*
    public static <T extends Text> T setMinLines(
            final T Text,
            final int minLines
    ) {
        if (Text != null && minLines > 0) {
            Text.setMinLines(minLines);
        }
        return Text;
    }
*/

    /**
     * 设置最小行数
     *
     * @param view     {@link Text}
     * @param minLines 最小行数
     * @return {@link View}
     */
  /*  public static View setMinLines(
            final View view,
            final int minLines
    ) {
        setMinLines(getTextView(view), minLines);
        return view;
    }*/

    // =

    /**
     * 获取最大字符宽度限制
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return 最大字符宽度限制
     */
  /*  @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
    public static <T extends Text> int getMaxEms(final T Text) {
        if (Text != null) {
            return Text.getMaxEms();
        }
        return 0;
    }*/

    /**
     * 设置最大字符宽度限制
     *
     * @param Text   {@link Text}
     * @param maxEms 最大字符
     * @param <T>    泛型
     * @return {@link Text}
     */
  /*  public static <T extends Text> T setMaxEms(
            final T Text,
            final int maxEms
    ) {
        if (Text != null && maxEms > 0) {
            Text.setMaxEms(maxEms);
        }
        return Text;
    }*/

    /**
     * 设置最大字符宽度限制
     *
     * @param view   {@link Text}
     * @param maxEms 最大字符
     * @return {@link Component}
     */
    public static Component setMaxEms(
            final Component view,
            final int maxEms
    ) {
        setMaxEms(getTextView(view), maxEms);
        return view;
    }

    // =

    /**
     * 获取最小字符宽度限制
     *
     * @param Text {@link Text}
     * @param <T>  泛型
     * @return 最小字符宽度限制
     */
   // @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
   /* public static <T extends Text> int getMinEms(final T Text) {
        if (Text != null) {
            return Text.getMinEms();
        }
        return 0;
    }*/

    /**
     * 设置最小字符宽度限制
     *
     * @param Text   {@link Text}
     * @param minEms 最小字符
     * @param <T>    泛型
     * @return {@link Text}
     */
  /*  public static <T extends Text> T setMinEms(
            final T Text,
            final int minEms
    ) {
        if (Text != null && minEms > 0) {
            Text.setMinEms(minEms);
        }
        return Text;
    }*/

    /**
     * 设置最小字符宽度限制
     *
     * @param view   {@link Text}
     * @param minEms 最小字符
     * @return {@link Component}
     */
   /* public static View setMinEms(
            final View view,
            final int minEms
    ) {
        setMinEms(getTextView(view), minEms);
        return view;
    }*/

    // =

    /**
     * 设置指定字符宽度
     *
     * @param Text {@link Text}
     * @param ems  字符
     * @param <T>  泛型
     * @return {@link Text}
     */
  /*  public static <T extends Text> T setEms(
            final T Text,
            final int ems
    ) {
        if (Text != null && ems > 0) {
            Text.setEms(ems);
        }
        return Text;
    }*/

    /**
     * 设置指定字符宽度
     *
     * @param view {@link Text}
     * @param ems  字符
     * @return {@link Component}
     */
  /*  public static View setEms(
            final View view,
            final int ems
    ) {
        setEms(getTextView(view), ems);
        return view;
    }*/

    // =

}